// 数据处理逻辑和业务服务层
import Logger from '../utils/Logger';

/**
 * 数据处理器，负责数据转换、业务规则处理等
 */
export class DataProcessor {
  /**
   * 处理用户列表数据
   * @param {Array} userList - 原始用户列表
   * @returns {Array} 处理后的用户列表
   */
  static process(userList) {
    Logger.info('DataProcessor', `开始处理${userList.length}条用户数据`);
    
    // 数据处理逻辑：
    // 1. 排序（按年龄降序）
    // 2. 数据转换
    // 3. 添加额外业务信息
    
    const processedList = userList
      .sort((a, b) => b.age - a.age)
      .map(user => {
        // 添加业务字段
        const experienceLevel = this.calculateExperienceLevel(user.age);
        const salaryLevel = this.calculateSalaryLevel(user.salary);
        
        return {
          ...user,
          experienceLevel,
          salaryLevel,
          // 格式化薪资显示
          formattedSalary: this.formatSalary(user.salary),
          // 计算工作年限（假设当前是2024年）
          workingYears: this.calculateWorkingYears(user.hireDate)
        };
      });
    
    Logger.info('DataProcessor', '用户数据处理完成');
    return processedList;
  }

  /**
   * 计算经验等级
   * @param {number} age - 年龄
   * @returns {string} 经验等级
   */
  static calculateExperienceLevel(age) {
    if (age < 25) {
      return '初级';
    } else if (age < 30) {
      return '中级';
    } else if (age < 40) {
      return '高级';
    } else {
      return '资深';
    }
  }

  /**
   * 计算薪资等级
   * @param {number} salary - 薪资
   * @returns {string} 薪资等级
   */
  static calculateSalaryLevel(salary) {
    if (salary < 10000) {
      return '基础';
    } else if (salary < 15000) {
      return '标准';
    } else if (salary < 20000) {
      return '良好';
    } else if (salary < 30000) {
      return '优秀';
    } else {
      return '卓越';
    }
  }

  /**
   * 格式化薪资显示
   * @param {number} salary - 薪资
   * @returns {string} 格式化后的薪资
   */
  static formatSalary(salary) {
    return `¥${salary.toLocaleString('zh-CN')}`;
  }

  /**
   * 计算工作年限
   * @param {string} hireDateStr - 入职日期字符串 (YYYY-MM-DD)
   * @returns {number} 工作年限
   */
  static calculateWorkingYears(hireDateStr) {
    try {
      const hireDate = new Date(hireDateStr);
      const now = new Date();
      const diffMs = now - hireDate;
      const diffYears = diffMs / (1000 * 60 * 60 * 24 * 365);
      return Math.floor(diffYears);
    } catch (error) {
      Logger.error('DataProcessor', '计算工作年限错误: ' + JSON.stringify(error));
      return 0;
    }
  }

  /**
   * 按部门分组统计用户
   * @param {Array} userList - 用户列表
   * @returns {Object} 部门统计信息
   */
  static groupByDepartment(userList) {
    Logger.info('DataProcessor', '按部门分组统计用户');
    
    const departmentStats = {};
    
    userList.forEach(user => {
      if (!departmentStats[user.department]) {
        departmentStats[user.department] = {
          count: 0,
          totalSalary: 0,
          avgSalary: 0,
          users: []
        };
      }
      
      departmentStats[user.department].count++;
      departmentStats[user.department].totalSalary += user.salary;
      departmentStats[user.department].users.push(user);
    });
    
    // 计算平均薪资
    Object.keys(departmentStats).forEach(deptName => {
      const dept = departmentStats[deptName];
      dept.avgSalary = Math.round(dept.totalSalary / dept.count);
    });
    
    return departmentStats;
  }

  /**
   * 搜索用户
   * @param {Array} userList - 用户列表
   * @param {string} keyword - 搜索关键词
   * @returns {Array} 搜索结果
   */
  static searchUsers(userList, keyword) {
    if (!keyword || keyword.trim() === '') {
      return userList;
    }
    
    const lowerKeyword = keyword.toLowerCase().trim();
    
    return userList.filter(user => {
      return (
        user.name.toLowerCase().includes(lowerKeyword) ||
        user.email.toLowerCase().includes(lowerKeyword) ||
        user.position.toLowerCase().includes(lowerKeyword) ||
        user.department.toLowerCase().includes(lowerKeyword)
      );
    });
  }

  /**
   * 验证用户数据
   * @param {Object} userData - 用户数据
   * @returns {Object} 验证结果 {isValid: boolean, errors: Array}
   */
  static validateUserData(userData) {
    const errors = [];
    
    // 基本验证
    if (!userData.name || userData.name.trim().length < 2) {
      errors.push('姓名至少需要2个字符');
    }
    
    if (!userData.age || userData.age < 18 || userData.age > 65) {
      errors.push('年龄必须在18-65岁之间');
    }
    
    // 邮箱格式验证
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (!userData.email || !emailRegex.test(userData.email)) {
      errors.push('邮箱格式不正确');
    }
    
    if (!userData.position) {
      errors.push('职位不能为空');
    }
    
    if (!userData.department) {
      errors.push('部门不能为空');
    }
    
    return {
      isValid: errors.length === 0,
      errors
    };
  }

  /**
   * 计算薪资统计信息
   * @param {Array} userList - 用户列表
   * @returns {Object} 薪资统计
   */
  static calculateSalaryStats(userList) {
    const salaries = userList.map(u => u.salary).sort((a, b) => a - b);
    
    return {
      min: salaries[0],
      max: salaries[salaries.length - 1],
      avg: Math.round(salaries.reduce((sum, s) => sum + s, 0) / salaries.length),
      median: salaries[Math.floor(salaries.length / 2)]
    };
  }
}